<!DOCTYPE HTML>
<html>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=1121528
-->
<head>
  <meta charset="utf-8">
  <title>Test for Bug 1121528</title>

  <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css">
  <script type="application/javascript;version=1.8" src="inspector-helpers.js"></script>
  <script type="application/javascript;version=1.8">
const inspector = require("devtools/shared/fronts/inspector");

window.onload = function() {
  SimpleTest.waitForExplicitFinish();
  runNextTest();
}

var gWalker, gDoc;

addAsyncTest(function() {
  let url = document.getElementById("inspectorContent").href;

  let def = promise.defer();
  attachURL(url, function(err, client, tab, doc) {
    def.resolve({client, tab, doc});
  });
  let {client, tab, doc} = yield def.promise;
  gDoc = doc;

  let {InspectorFront} = require("devtools/shared/fronts/inspector");
  let inspector = InspectorFront(client, tab);
  gWalker = yield inspector.getWalker();

  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.parents(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.parents(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.parents() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.children(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "body");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.children(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.children() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.siblings(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.siblings(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.siblings() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.nextSibling(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.nextSibling(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.nextSibling() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.previousSibling(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.previousSibling(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.previousSibling() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.addPseudoClassLock(nodeFront) before the load completes " +
    "shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.addPseudoClassLock(nodeFront, ":hover");
  yield newRoot;

  ok(true, "The call to walker.addPseudoClassLock() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.removePseudoClassLock(nodeFront) before the load completes " +
    "shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.removePseudoClassLock(nodeFront, ":hover");
  yield newRoot;

  ok(true, "The call to walker.removePseudoClassLock() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.clearPseudoClassLocks(nodeFront) before the load completes " +
    "shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.clearPseudoClassLocks(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.clearPseudoClassLocks() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.innerHTML(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.innerHTML(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.innerHTML() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.setInnerHTML(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.setInnerHTML(nodeFront, "<span>innerHTML changed</span>");
  yield newRoot;

  ok(true, "The call to walker.setInnerHTML() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.outerHTML(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.outerHTML(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.outerHTML() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.setOuterHTML(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.setOuterHTML(nodeFront, "<h1><span>innerHTML changed</span></h1>");
  yield newRoot;

  ok(true, "The call to walker.setOuterHTML() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.insertAdjacentHTML(nodeFront) before the load completes shouldn't " +
    "fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.insertAdjacentHTML(nodeFront, "afterEnd",
    "<span>new adjacent HTML</span>");
  yield newRoot;

  ok(true, "The call to walker.insertAdjacentHTML() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.removeNode(nodeFront) before the load completes should throw");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  let hasThrown = false;
  try {
    yield gWalker.removeNode(nodeFront);
  } catch (e) {
    hasThrown = true;
  }
  yield newRoot;

  ok(hasThrown, "The call to walker.removeNode() threw");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.removeNodes([nodeFront]) before the load completes should throw");

  let nodeFront1 = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let nodeFront2 = yield gWalker.querySelector(gWalker.rootNode, "#longstring");
  let nodeFront3 = yield gWalker.querySelector(gWalker.rootNode, "#shortstring");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  let hasThrown = false;
  try {
    yield gWalker.removeNodes([nodeFront1, nodeFront2, nodeFront3]);
  } catch (e) {
    hasThrown = true;
  }
  yield newRoot;

  ok(hasThrown, "The call to walker.removeNodes() threw");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.insertBefore(nodeFront, parent, null) before the load completes " +
    "shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newParentFront = yield gWalker.querySelector(gWalker.rootNode, "#longlist");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.insertBefore(nodeFront, newParentFront);
  yield newRoot;

  ok(true, "The call to walker.insertBefore() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.insertBefore(nodeFront, parent, sibling) before the load completes " +
    "shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newParentFront = yield gWalker.querySelector(gWalker.rootNode, "#longlist");
  let siblingFront = yield gWalker.querySelector(gWalker.rootNode, "#b");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.insertBefore(nodeFront, newParentFront, siblingFront);
  yield newRoot;

  ok(true, "The call to walker.insertBefore() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.editTagName(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.editTagName(nodeFront, "h2");
  yield newRoot;

  ok(true, "The call to walker.editTagName() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.hideNode(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.hideNode(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.hideNode() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.unhideNode(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.unhideNode(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.unhideNode() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.releaseNode(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "h1");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.releaseNode(nodeFront);
  yield newRoot;

  ok(true, "The call to walker.releaseNode() didn't fail");
  runNextTest();
});

addAsyncTest(function() {
  info("Getting a nodeFront, reloading the page, and calling " +
    "walker.querySelector(nodeFront) before the load completes shouldn't fail");

  let nodeFront = yield gWalker.querySelector(gWalker.rootNode, "body");
  let newRoot = waitForMutation(gWalker, isNewRoot);
  gDoc.defaultView.location.reload();
  yield gWalker.querySelector(nodeFront, "h1");
  yield newRoot;

  ok(true, "The call to walker.querySelector() didn't fail");
  runNextTest();
});

addTest(function cleanup() {
  gWalker = gDoc = null;
  runNextTest();
});
  </script>
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=932937">Mozilla Bug 1121528</a>
<a id="inspectorContent" target="_blank" href="inspector-traversal-data.html">Test Document</a>
<p id="display"></p>
<div id="content" style="display: none">

</div>
<pre id="test">
</pre>
</body>
</html>
